package c

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"strconv"
	"strings"

	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/model/community"
	"github.com/flipped-aurora/gin-vue-admin/server/model/community/request"
	"github.com/flipped-aurora/gin-vue-admin/server/model/community/response"
	sysModel "github.com/flipped-aurora/gin-vue-admin/server/model/system"
	systemReq "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
	"github.com/flipped-aurora/gin-vue-admin/server/service/system"
	"go.uber.org/zap"
	"gorm.io/gorm"
	"time"
)

type CommunityService struct{}

// CommunityServiceApp 社区模块业务层实例
var CommunityServiceApp = new(CommunityService)

// GetCommunityDetail 获取社区详情，按照社区ID、专业ID、用户专业ID的优先级逻辑查询
func (s *CommunityService) GetCommunityDetail(communityIdStr string, majorIdStr string) (community.Community, error) {
	var communityInfo community.Community
	var err error

	// 1. 优先使用社区ID查询
	if communityIdStr != "" {
		communityId, err := strconv.ParseInt(communityIdStr, 10, 64)
		if err != nil {
			return communityInfo, errors.New("社区ID格式错误")
		}
		err = global.GVA_DB.Where("id = ? AND status = 0", communityId).First(&communityInfo).Error
		if err == nil {
			return communityInfo, nil
		}
		// 只有在记录不存在的情况下才继续，其他错误直接返回
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return communityInfo, err
		}
	}

	// 2. 使用专业ID查询
	if majorIdStr != "" {
		majorId, err := strconv.Atoi(majorIdStr)
		if err != nil {
			return communityInfo, errors.New("专业ID格式错误")
		}
		// 13大类阶段，通过专业id转换为对应的大类社区
		// 调用GetTopLevelParentID函数获取专业大类ID
		majorCategoryId, err := system.DictionaryDetailServiceApp.GetTopLevelParentID(uint(majorId))
		if err != nil {
			// 获取专业大类ID失败，记录错误并继续尝试直接查询
			global.GVA_LOG.Error("获取专业大类ID失败", zap.Error(err))
		} else if majorCategoryId > 0 {
			// 使用专业大类ID查询社区
			err = global.GVA_DB.Where("discipline_category_id = ? AND status = 0", majorCategoryId).First(&communityInfo).Error
			if err == nil {
				return communityInfo, nil
			}
			// 只有在记录不存在的情况下才继续，其他错误直接返回
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return communityInfo, err
			}
		}

		// 尝试直接使用原始专业ID查询社区
		err = global.GVA_DB.Where("professional_category_id = ? AND status = 0", majorId).First(&communityInfo).Error
		if err == nil {
			return communityInfo, nil
		}
		// 只有在记录不存在的情况下才继续，其他错误直接返回
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return communityInfo, err
		}
	}

	// 3. 默认返回第一个正常状态的社区
	err = global.GVA_DB.Where("status = 0").Order("id ASC").First(&communityInfo).Error
	if err != nil {
		return communityInfo, errors.New("获取社区详情失败")
	}

	return communityInfo, nil
}

// GetCommunityList 获取社区列表
func (s *CommunityService) GetCommunityList(pageInfo request.CommunityListRequest) ([]community.Community, int64, error) {
	var list []community.Community
	var total int64
	limit := pageInfo.PageSize
	offset := pageInfo.PageSize * (pageInfo.Page - 1)
	db := global.GVA_DB.Model(&community.Community{}).Where("status = 0")

	// 搜索条件
	if pageInfo.Keyword != "" {
		db = db.Where("name LIKE ?", "%"+pageInfo.Keyword+"%")
	}

	// 按类型筛选
	if pageInfo.Type > -1 {
		db = db.Where("type = ?", pageInfo.Type)
	}

	// 按学科类别筛选
	if pageInfo.DisciplineCategoryID > 0 {
		db = db.Where("discipline_category_id = ?", pageInfo.DisciplineCategoryID)
	}

	// 按专业类别筛选
	if pageInfo.MajorCategoryID > 0 {
		db = db.Where("major_category_id = ?", pageInfo.MajorCategoryID)
	}

	err := db.Count(&total).Error
	if err != nil {
		return list, total, err
	}
	// 使用正确的字段名 CreatedAt 进行排序
	err = db.Limit(limit).Offset(offset).Order("created_at DESC").Find(&list).Error
	return list, total, err
}

// JoinCommunity 加入社区
func (s *CommunityService) JoinCommunity(userId uint, communityId uint) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		// 检查社区是否存在且状态正常
		var communityInfo community.Community
		err := tx.Set("gorm:query_option", "FOR UPDATE").Where("id = ? AND status = 0", communityId).First(&communityInfo).Error
		if err != nil {
			return errors.New("社区不存在或已被禁用")
		}

		// 检查用户是否已加入该社区
		var communityUser community.CommunityUser
		err = tx.Where("user_id = ? AND community_id = ?", userId, communityId).First(&communityUser).Error
		if err == nil {
			return errors.New("您已加入该社区")
		}
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}

		// 创建社区用户关系
		newCommunityUser := community.CommunityUser{
			UserID:      userId,
			CommunityID: communityId,
			Role:        1, // 普通成员
		}
		err = tx.Create(&newCommunityUser).Error
		if err != nil {
			return err
		}

		// 更新社区成员数量
		err = tx.Model(&communityInfo).Update("member_cnt", communityInfo.MemberCnt+1).Error
		if err != nil {
			return err
		}

		return nil
	})
}

// LeaveCommunity 离开社区
func (s *CommunityService) LeaveCommunity(userId uint, communityId uint) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		// 检查社区用户关系是否存在
		var communityUser community.CommunityUser
		err := tx.Where("user_id = ? AND community_id = ?", userId, communityId).First(&communityUser).Error
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return errors.New("您未加入该社区")
			}
			return err
		}

		// 删除社区用户关系
		err = tx.Delete(&communityUser).Error
		if err != nil {
			return err
		}

		// 更新社区成员数量，确保不小于0
		err = tx.Exec("UPDATE community SET member_cnt = GREATEST(member_cnt - 1, 0) WHERE id = ?", communityId).Error
		if err != nil {
			return err
		}

		return nil
	})
}

// GetMajorCategoriesWithCommunity 获取专业大类及对应社区id
func (s *CommunityService) GetMajorCategoriesWithCommunity() ([]map[string]interface{}, error) {
	// 专业字典ID为9
	const majorDictionaryID = 9

	// 查询专业大类（parent_id为NULL的顶级节点）
	var req systemReq.SysDictionaryDetailTreeRequest
	req.SysDictionaryID = majorDictionaryID
	req.ParentID = nil

	// 调用系统字典服务获取专业大类
	majorCategories, err := system.DictionaryDetailServiceApp.GetDictionaryDetailTree(req)
	if err != nil {
		return nil, err
	}

	// 处理结果，添加社区信息
	result := make([]map[string]interface{}, 0)

	for _, category := range majorCategories {
		// 处理专业类名称中的括号备注
		label := category.Label
		if idx := strings.Index(label, "("); idx > 0 {
			label = label[:idx]
		}

		// 将专业ID转换为int64
		majorCategoryID, err := strconv.ParseInt(category.Value, 10, 64)
		if err != nil {
			global.GVA_LOG.Error("专业ID转换失败", zap.String("value", category.Value), zap.Error(err))
			// 添加错误信息到结果集，而不是完全跳过
			result = append(result, map[string]interface{}{
				"label": label,
				"value": category.Value,
				"error": "专业ID格式错误",
			})
			continue
		}

		// 查询对应的社区信息
		var communityInfo community.Community
		err = global.GVA_DB.Where("major_category_id = ? AND status = 0", majorCategoryID).First(&communityInfo).Error
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				global.GVA_LOG.Error("未找到对应的社区", zap.Int64("majorCategoryID", majorCategoryID))
			} else {
				global.GVA_LOG.Error("查询社区信息失败", zap.Int64("majorCategoryID", majorCategoryID), zap.Error(err))
			}
			continue // 跳过此专业类
		}

		// 添加到结果集
		result = append(result, map[string]interface{}{
			"label":         label,
			"value":         category.Value,
			"communityId":   communityInfo.ID,
			"communityName": communityInfo.Name,
		})
	}

	return result, nil
}

// GetCommunityByMajorID 根据专业ID获取对应的社区
func (s *CommunityService) GetCommunityByMajorID(majorID int) (community.Community, error) {
	var communityInfo community.Community

	// 验证专业ID的有效性
	if majorID <= 0 {
		return communityInfo, errors.New("无效的专业ID")
	}

	// 专业字典ID为9
	const majorDictionaryID = 9

	// 1. 首先检查传入的majorID是否为三级专业ID
	// 查询字典详情获取专业ID的父级信息
	sysDictDetail, err := system.DictionaryDetailServiceApp.GetSysDictionaryDetail(uint(majorID))
	if err == nil && sysDictDetail.SysDictionaryID == majorDictionaryID {
		// 2. 如果是字典详情且属于专业字典，则检查是否存在父级ID
		if sysDictDetail.ParentID != nil {
			// 3. 如果有父级ID，则使用父级ID查询社区（这是二级专业类ID）
			err = global.GVA_DB.Where("major_category_id = ? AND status = 0", *sysDictDetail.ParentID).First(&communityInfo).Error
			if err == nil {
				return communityInfo, nil
			}
		}
	}

	// 4. 如果不是三级专业ID或查询父级ID失败，则尝试直接使用传入的majorID查询社区
	err = global.GVA_DB.Where("major_category_id = ? AND status = 0", majorID).First(&communityInfo).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return communityInfo, errors.New("未找到与您专业对应的社区")
		}
		return communityInfo, err
	}
	return communityInfo, nil
}

// GetCommunityByDisciplineID 根据学科类别ID获取对应的社区
func (s *CommunityService) GetCommunityByDisciplineID(disciplineID int) (community.Community, error) {
	var communityInfo community.Community

	// 验证专业ID的有效性
	if disciplineID <= 0 {
		return communityInfo, errors.New("无效的学科专业ID")
	}

	err := global.GVA_DB.Where("discipline_category_id = ? AND status = 0", disciplineID).First(&communityInfo).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return communityInfo, errors.New("未找到学科类别社区")
		}
		return communityInfo, err
	}
	return communityInfo, nil
}

// CheckUserMajorWithCommunity 检查用户专业是否与社区匹配； 学科类别-专业类别-专业
func (s *CommunityService) CheckUserMajorWithCommunity(majorID int, communityID uint) error {
	var communityInfo community.Community
	err := global.GVA_DB.Where("id = ? AND status = 0", communityID).First(&communityInfo).Error

	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errors.New("指定的社区不存在")
		}
		return err
	}

	// 若community是学科类别社区，则返回非法操作社区
	if communityInfo.ProfessionalCategoryID == 0 &&
		communityInfo.MajorCategoryID == 0 {
		return fmt.Errorf("学科类别社区非法操作！社区id: %d", communityInfo.ID)
	}

	// 若community是专业社区，则校验 用户专业 与 社区对应专业
	if communityInfo.ProfessionalCategoryID > 0 {
		if communityInfo.ProfessionalCategoryID == majorID {
			return nil
		}
		return errors.New("您不能操作内容到非本专业的社区")
	}

	// 若community是专业类别社区，则校验用户所属专业的 专业类别 和 社区对应的专业类别
	if communityInfo.MajorCategoryID > 0 {
		// 查询用户所属专业的字典表记录
		var dictionary sysModel.SysDictionaryDetail
		errDict := global.GVA_DB.Where("id = ? and sys_dictionary_id = ? ", majorID, global.DictionaryMajor).First(&dictionary).Error
		if errDict != nil {
			return fmt.Errorf("获取用户专业字典表记录失败! major_id=%d, err=%w", majorID, errDict)
		}
		// 获取用户所属的 专业类别
		userMajorCategoryID := dictionary.ParentID
		if userMajorCategoryID != nil && int(*userMajorCategoryID) == communityInfo.MajorCategoryID {
			return nil
		}
		return errors.New("您不能操作内容到非本专业类别的社区")
	}

	return nil
}

// CheckCommunityExists 查询社区是否存在
func (s *CommunityService) CheckCommunityExists(communityId uint) (bool, error) {
	var count int64
	err := global.GVA_DB.Model(&community.Community{}).
		Where("id = ? AND status = 0", communityId).
		Count(&count).Error
	if err != nil {
		return false, err
	}
	return count > 0, nil
}

// UpdateCommunityArticleCount 更新社区文章数量
// increment: 增量值，正数表示增加，负数表示减少
func (s *CommunityService) UpdateCommunityArticleCount(communityID uint, increment int64) error {
	// 确保增量在合理范围内
	if increment < -100 || increment > 100 {
		return errors.New("增量值超出合理范围")
	}

	// 更新社区文章数量，确保不小于0
	err := global.GVA_DB.Exec(
		"UPDATE community SET article_cnt = GREATEST(article_cnt + ?, 0) WHERE id = ? AND status = 0",
		increment, communityID,
	).Error

	if err != nil {
		global.GVA_LOG.Error("更新社区文章数量失败",
			zap.Uint("communityID", communityID),
			zap.Int64("increment", increment),
			zap.Error(err))
		return errors.New("更新社区文章数量失败: " + err.Error())
	}

	return nil
}

// GetUserCommunityID 查询用户所在社区ID
func (s *CommunityService) GetUserCommunityID(userId uint) (uint, error) {
	var communityUser community.CommunityUser

	// 查询用户加入的社区关系
	err := global.GVA_DB.Where("user_id = ?", userId).First(&communityUser).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return 0, errors.New("用户未加入任何社区")
		}
		return 0, err
	}

	// 验证社区是否存在且状态正常
	var communityInfo community.Community
	err = global.GVA_DB.Where("id = ? AND status = 0", communityUser.CommunityID).First(&communityInfo).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return 0, errors.New("用户所在社区不存在或已被禁用")
		}
		return 0, err
	}

	return communityUser.CommunityID, nil
}

// ValidateCommunityMajorRelation 校验社区与专业关系，设置空DisciplineCategoryID社区的专业大类
func (s *CommunityService) ValidateCommunityMajorRelation() error {
	// 专业字典ID为9
	const majorDictionaryID = 9

	var communities []community.Community
	err := global.GVA_DB.Where("discipline_category_id = 0 AND status = 0").Find(&communities).Error
	if err != nil {
		return errors.New("查询空专业类社区失败: " + err.Error())
	}

	if len(communities) == 0 {
		return nil // 没有需要处理的社区
	}

	// 遍历社区处理
	for i := range communities {
		community := &communities[i]

		if community.MajorCategoryID > 0 {
			// 安全类型转换
			majorCategoryID := uint(community.MajorCategoryID)
			if majorCategoryID > 0 {
				dictDetail, err := system.DictionaryDetailServiceApp.GetSysDictionaryDetail(majorCategoryID)
				if err == nil && dictDetail.SysDictionaryID == majorDictionaryID {
					if dictDetail.ParentID != nil {
						community.DisciplineCategoryID = int(*dictDetail.ParentID)
						// 更新社区信息
						err = global.GVA_DB.Model(community).Update("discipline_category_id", community.DisciplineCategoryID).Error
						if err != nil {
							global.GVA_LOG.Error("更新社区专业大类ID失败",
								zap.Uint("communityID", community.ID),
								zap.Int("majorCategoryID", community.MajorCategoryID),
								zap.Error(err))
						} else {
							global.GVA_LOG.Info("更新社区专业大类ID成功",
								zap.Uint("communityID", community.ID),
								zap.Int("disciplineCategoryID", community.DisciplineCategoryID))
						}
					}
				} else {
					global.GVA_LOG.Error("查询专业详情失败或不属于专业字典",
						zap.Uint("communityID", community.ID),
						zap.Int("majorCategoryID", community.MajorCategoryID),
						zap.Error(err))
				}
			}
		}
	}

	return nil
}

// CheckSameDisciplineCategory 比较两个社区是否在同一个专业大类
func (s *CommunityService) CheckSameDisciplineCategory(communityId1 uint, communityId2 uint) (bool, error) {
	// 检查两个社区ID是否相同
	if communityId1 == communityId2 {
		return true, nil
	}

	// 查询第一个社区信息
	var community1 community.Community
	err := global.GVA_DB.Where("id = ? AND status = 0", communityId1).First(&community1).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return false, errors.New("第一个社区不存在或已被禁用")
		}
		return false, err
	}

	// 查询第二个社区信息
	var community2 community.Community
	err = global.GVA_DB.Where("id = ? AND status = 0", communityId2).First(&community2).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return false, errors.New("第二个社区不存在或已被禁用")
		}
		return false, err
	}

	// 比较两个社区是否在同一个专业大类
	return community1.DisciplineCategoryID == community2.DisciplineCategoryID, nil
}

// GetCommunityTree 获取社区二层树结构（1层是13大类对应的虚拟社区，2层为关联虚拟社区实际的物理社区）
func (s *CommunityService) GetCommunityTree(ctx context.Context) ([]response.CommunityTreeNode, error) {
	// 1. 定义缓存键
	cacheKey := "community_tree"

	// 2. 尝试从Redis获取缓存
	if global.GVA_CONFIG.System.UseRedis && global.GVA_REDIS != nil {
		// 从Redis获取缓存的JSON字符串
		cachedData, err := global.GVA_REDIS.Get(ctx, cacheKey).Result()
		if err == nil {
			// 缓存命中，反序列化数据
			var treeData []response.CommunityTreeNode
			if err := json.Unmarshal([]byte(cachedData), &treeData); err == nil {
				// 为缓存续命，设置为1天过期
				global.GVA_REDIS.Expire(ctx, cacheKey, 24*time.Hour)
				return treeData, nil
			}
			// 反序列化失败，记录错误但继续查询数据库
			global.GVA_LOG.Error("从缓存反序列化社区树数据失败", zap.Error(err))
		}
	}

	// 3. 缓存未命中，执行数据库查询逻辑
	// 获取所有正常状态的虚拟社区（类型为0）
	var virtualCommunities []community.Community
	err := global.GVA_DB.Where("type = ? AND status = 0", 0).Order("id").Find(&virtualCommunities).Error
	if err != nil {
		return nil, errors.New("查询虚拟社区失败: " + err.Error())
	}

	// 创建社区树
	var communityTree []response.CommunityTreeNode
	for _, virtualCommunity := range virtualCommunities {
		// 创建虚拟社区节点
		node := response.CommunityTreeNode{
			Community: virtualCommunity,
			Children:  []response.CommunityTreeNode{},
		}

		// 获取关联该虚拟社区的物理社区（类型为1）
		// 通过学科类别ID关联
		var physicalCommunities []community.Community
		err := global.GVA_DB.Where(
			"type = ? AND status = 0 AND discipline_category_id = ?",
			1, virtualCommunity.DisciplineCategoryID,
		).Order("id").Find(&physicalCommunities).Error
		if err != nil {
			global.GVA_LOG.Error("查询物理社区失败", zap.Error(err))
			continue
		}

		// 添加物理社区作为子节点
		for _, physicalCommunity := range physicalCommunities {
			childNode := response.CommunityTreeNode{
				Community: physicalCommunity,
				Children:  []response.CommunityTreeNode{}, // 物理社区没有子节点
			}
			node.Children = append(node.Children, childNode)
		}

		communityTree = append(communityTree, node)
	}

	// 4. 将查询结果存入Redis，设置1天过期时间
	if global.GVA_CONFIG.System.UseRedis && global.GVA_REDIS != nil && err == nil {
		// 序列化数据为JSON
		jsonData, err := json.Marshal(communityTree)
		if err == nil {
			// 存入Redis，过期时间设为24小时
			err = global.GVA_REDIS.Set(ctx, cacheKey, string(jsonData), 24*time.Hour).Err()
			if err != nil {
				// 缓存设置失败，记录错误但不影响返回结果
				global.GVA_LOG.Error("设置社区树缓存失败", zap.Error(err))
			}
		} else {
			global.GVA_LOG.Error("序列化社区树数据失败", zap.Error(err))
		}
	}

	return communityTree, nil
}

// GetSimpleCommunityTree 获取简化的社区二层树结构
// 返回包含1层13大类虚拟社区和2层关联物理社区的树形结构
// 为接口添加1天有效期的Redis缓存
func (communityService *CommunityService) GetSimpleCommunityTree(ctx context.Context) ([]response.SimpleCommunityTreeNode, error) {
	// 定义缓存键
	cacheKey := "simple_community_tree"

	// 1. 尝试从Redis缓存获取数据
	var tree []response.SimpleCommunityTreeNode

	// 检查是否启用Redis并且Redis客户端不为空
	if global.GVA_CONFIG.System.UseRedis && global.GVA_REDIS != nil {
		// 使用传入的上下文，如果为空则使用Background上下文
		redisCtx := ctx
		if redisCtx == nil {
			redisCtx = context.Background()
		}

		// 从Redis获取缓存的JSON字符串
		cacheData, err := global.GVA_REDIS.Get(redisCtx, cacheKey).Result()
		if err == nil {
			// 缓存命中，反序列化数据
			if err := json.Unmarshal([]byte(cacheData), &tree); err == nil {
				// 为缓存续命，设置为1天过期
				global.GVA_REDIS.Expire(redisCtx, cacheKey, 24*time.Hour)
				return tree, nil
			}
			// 反序列化失败，记录错误但继续查询数据库
			global.GVA_LOG.Error("从缓存反序列化简化社区树数据失败", zap.Error(err))
		}
	}

	// 2. 缓存未命中，从数据库查询并构建树结构

	// 查询所有虚拟社区（Type=0）作为第一层
	var virtualCommunities []community.Community
	err := global.GVA_DB.Where("type = ?", 0).Find(&virtualCommunities).Error
	if err != nil {
		return nil, err
	}

	// 查询所有物理社区（Type=1）作为第二层
	var physicalCommunities []community.Community
	err = global.GVA_DB.Where("type = ?", 1).Find(&physicalCommunities).Error
	if err != nil {
		return nil, err
	}

	// 构建社区树结构
	tree = buildSimpleCommunityTree(virtualCommunities, physicalCommunities)

	// 3. 将结果存入Redis缓存，有效期1天
	if global.GVA_CONFIG.System.UseRedis && global.GVA_REDIS != nil {
		// 使用传入的上下文，如果为空则使用Background上下文
		redisCtx := ctx
		if redisCtx == nil {
			redisCtx = context.Background()
		}

		// 序列化数据为JSON
		treeData, err := json.Marshal(tree)
		if err == nil {
			// 存入Redis，过期时间设为24小时
			err = global.GVA_REDIS.Set(redisCtx, cacheKey, string(treeData), 24*time.Hour).Err()
			if err != nil {
				// 缓存设置失败，记录错误但不影响返回结果
				global.GVA_LOG.Error("设置简化社区树缓存失败", zap.Error(err))
			}
		} else {
			global.GVA_LOG.Error("序列化简化社区树数据失败", zap.Error(err))
		}
	}

	return tree, nil
}

// buildSimpleCommunityTree 构建简化的社区树结构
// 通过 discipline_category_id 将虚拟社区和物理社区关联起来
func buildSimpleCommunityTree(virtualCommunities, physicalCommunities []community.Community) []response.SimpleCommunityTreeNode {
	// 创建虚拟社区到物理社区的映射
	physicalMap := make(map[int][]community.Community)
	for _, pc := range physicalCommunities {
		physicalMap[pc.DisciplineCategoryID] = append(physicalMap[pc.DisciplineCategoryID], pc)
	}

	// 构建树结构
	var tree []response.SimpleCommunityTreeNode
	for _, vc := range virtualCommunities {
		// 创建虚拟社区节点
		node := response.SimpleCommunityTreeNode{
			Community: response.SimpleCommunity{
				ID:               vc.ID,
				Name:             vc.Name,
				Image:            vc.Image,
				ProfessionalName: system.UserServiceApp.GetProfessionalNameByID(vc.DisciplineCategoryID),
			},
			Children: []response.SimpleCommunityTreeNode{},
		}

		// 添加关联的物理社区作为子节点
		if physicalCommunities, exists := physicalMap[vc.DisciplineCategoryID]; exists {
			for _, pc := range physicalCommunities {
				childNode := response.SimpleCommunityTreeNode{
					Community: response.SimpleCommunity{
						ID:               pc.ID,
						Name:             pc.Name,
						Image:            pc.Image,
						ProfessionalName: system.UserServiceApp.GetProfessionalNameByID(pc.MajorCategoryID),
					},
					Children: []response.SimpleCommunityTreeNode{},
				}
				node.Children = append(node.Children, childNode)
			}
		}

		tree = append(tree, node)
	}

	return tree
}

// GetCommunityByID 根据ID获取社区信息
func (s *CommunityService) GetCommunityByID(communityID uint) (community.Community, error) {
	var communityInfo community.Community

	// 查询社区信息
	err := global.GVA_DB.Where("id = ? AND status = 0", communityID).First(&communityInfo).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return communityInfo, errors.New("社区不存在或已被禁用")
		}
		global.GVA_LOG.Error("查询社区信息失败",
			zap.Uint("communityID", communityID),
			zap.Error(err))
		return communityInfo, err
	}

	global.GVA_LOG.Debug("查询社区信息成功",
		zap.Uint("communityID", communityID),
		zap.String("communityName", communityInfo.Name))

	return communityInfo, nil
}
